.TH std::nan,std::nanf,std::nanl 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::nan,std::nanf,std::nanl \- std::nan,std::nanf,std::nanl

.SH Synopsis
   Defined in header <cmath>
   float       nanf( const char* arg ); \fB(1)\fP \fI(since C++11)\fP
   double      nan ( const char* arg ); \fB(2)\fP \fI(since C++11)\fP
   long double nanl( const char* arg ); \fB(3)\fP \fI(since C++11)\fP

   Converts the character string arg into the corresponding quiet NaN value, as if by
   calling std::strtof, std::strtod, or std::strtold, respectively.

   1) The call std::nanf("n-char-sequence"), where n-char-sequence is a sequence of
   digits, ASCII letters, and underscores, is equivalent to the call
   std::strtof("NAN(n-char-sequence)", (char**)nullptr);.
   The call std::nanf("") is equivalent to the call std::strtof("NAN()",
   (char**)nullptr);.
   The call std::nanf("string"), where string is neither an n-char-sequence nor an
   empty string, is equivalent to the call std::strtof("NAN", (char**)nullptr);.
   2) Same as \fB(1)\fP, but calls std::strtod instead of std::strtof.
   3) Same as \fB(1)\fP, but calls std::strtold instead of std::strtof.

.SH Parameters

   arg - narrow character string identifying the contents of a NaN

.SH Return value

   The quiet NaN value that corresponds to the identifying string arg or zero if the
   implementation does not support quiet NaNs.

   If the implementation supports IEEE floating-point arithmetic (IEC 60559), it also
   supports quiet NaNs.

.SH Error handling

   This function is not subject to any of the error conditions specified in
   math_errhandling.

.SH Example


// Run this code

 #include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <iostream>

 int main()
 {
     double f1 = std::nan("1");
     std::uint64_t f1n; std::memcpy(&f1n, &f1, sizeof f1);
     std::cout << "nan(\\"1\\") = " << f1 << " (" << std::hex << f1n << ")\\n";

     double f2 = std::nan("2");
     std::uint64_t f2n; std::memcpy(&f2n, &f2, sizeof f2);
     std::cout << "nan(\\"2\\") = " << f2 << " (" << std::hex << f2n << ")\\n";
 }

.SH Possible output:

 nan("1") = nan (7ff0000000000001)
 nan("2") = nan (7ff0000000000002)

.SH See also

   isnan             checks if the given number is NaN
   \fI(C++11)\fP           \fI(function)\fP
   NAN               evaluates to a quiet NaN of type float
   \fI(C++11)\fP           (macro constant)
   has_quiet_NaN     identifies floating-point types that can represent the special
   \fB[static]\fP          value "quiet not-a-number" (NaN)
                     \fI(public static member constant of std::numeric_limits<T>)\fP
   has_signaling_NaN identifies floating-point types that can represent the special
   \fB[static]\fP          value "signaling not-a-number" (NaN)
                     \fI(public static member constant of std::numeric_limits<T>)\fP
   quiet_NaN         returns a quiet NaN value of the given floating-point type
   \fB[static]\fP          \fI(public static member function of std::numeric_limits<T>)\fP
   signaling_NaN     returns a signaling NaN value of the given floating-point type
   \fB[static]\fP          \fI(public static member function of std::numeric_limits<T>)\fP
   C documentation for
   nanf,
   nan,
   nanl
